package com.gyms.manager;

import com.classic.okhttp.beans.HVCardBean;
import com.classic.okhttp.beans.HVCardProductsBean;
import com.classic.okhttp.beans.HVCardVenuesBean;
import com.classic.okhttp.beans.HVCardWorkTimeBean;
import com.classic.okhttp.beans.HVMyOrderInfoBean;
import com.classic.okhttp.beans.HVProductOrderFieldBean;
import com.classic.okhttp.beans.HVVenueOrderFieldBean;

import java.util.ArrayList;
import java.util.Date;
import java.util.Iterator;
import java.util.List;

import utils.Arith;
import utils.DateUtil;
import utils.StringUtils;

/**
 * ltx on 2016/12/22 15:14
 * 优惠劵
 */
public class CouponManger {
    private static CouponManger instance=null;
    private final static int GYM=1;
    private final static int PRODUCT=2;
    private final static int ALL_PRODUCT_AND_GYM=1;//所有场馆和所有的产品都有效
    private final static int ALL_GYM=2;//所有场馆的场地预定全部有效，指定场馆的产品售卖有效
    private final static int ALL_PRODUCT=3;//所有场馆的产品售卖全部有效，指定场馆的
    private final static int PART_GYM_PART_PRODUCT=4;//指定场馆的产品售卖有效，指定场馆的场地预定有效
    private final static int FULL_CUT=1;//满减优惠
    private final static int DEDUCTION=2;//抵扣优惠
    //优惠类型   1= 满减优惠  2= 抵扣优惠
    private int couponType;

    private HVMyOrderInfoBean mMyOrderInfoBean;//我的订单详情Bean
    private ArrayList<HVCardBean> mHVCardBeans;//我的卡卷列表 筛选后 过期以及使用过的


   // 创建的卡卷列表
    private ArrayList<HVCardBean> mCanUseCarbeans=new ArrayList<>();//可用的优惠卷list
    private ArrayList<HVCardBean> mNoUseCarbeans=new ArrayList<>();//不可用的优惠卷list
    private ArrayList<HVCardBean> mNewCarBeans=new ArrayList<>();//组装后的Bean

    //产品Id
    private  String productId;
    //场馆Id
    private  String gymId;

    private boolean isRemove;

    private ArrayList<Integer> mAvailableCouponList;//符合该订单的卡卷Id

    private String mVenueId;// 订单的场馆iD


    private CouponManger() {
        instance = this;
    }
    public static CouponManger getInstance() {
        if (instance == null) {
            instance = new CouponManger();
        }
        return instance;
    }

    /**
     * 初始化数据
     * @param mMyOrderInfoBean 我的订单详情bean
     * @param mHVCardBeans 我的卡卷bean
     * @param mAvailableCouponList 可用的卡卷id
     */
    public void initData(HVMyOrderInfoBean mMyOrderInfoBean,ArrayList<HVCardBean> mHVCardBeans,ArrayList<Integer> mAvailableCouponList){
        this.mMyOrderInfoBean=mMyOrderInfoBean;
        this.mHVCardBeans=mHVCardBeans;
        this.mAvailableCouponList=mAvailableCouponList;
        if(!StringUtils.isNull(mMyOrderInfoBean)){
            mVenueId=mMyOrderInfoBean.getVenueId();
        }
        if (!StringUtils.isNull(mCanUseCarbeans)) {
            mCanUseCarbeans.clear();//可用的优惠卷list
        }
        if(!StringUtils.isNull(mNoUseCarbeans)){
            mNoUseCarbeans.clear();//不可用的优惠卷list
        }
        if(!StringUtils.isNull(mNewCarBeans)){
            mNewCarBeans.clear();//组装后的Bean
        }
        if (null != mMyOrderInfoBean.getOrderProduct()) {
            productId = mMyOrderInfoBean.getOrderProduct().getProductTypeId();//产品Id
        }
        gymId=mMyOrderInfoBean.getVenueId();//场馆d 符合改场馆的就可以优惠
        doDeleteUnable();
    }

    /**
     * 移出过期的或者已使用的
     */

    private void doDeleteUnable() {

        for(int i=0;i<mHVCardBeans.size();i++){
            HVCardBean mHVCardBean=mHVCardBeans.get(i);

            //判断是否过期并且未生效
            boolean isOver=doCheckIsOver(mHVCardBean);
           boolean isUse= mHVCardBean.getAvailable();//是能使用 true 表示未使用 false 表示已经使用
             if(isOver||!isUse){//过期或者已经使用
                mHVCardBeans.remove(i);//移除该项
                 i--;
                mNoUseCarbeans.add(mHVCardBean);//添加到不可用的list
            }
        }

    }

    private boolean doCheckIsOver(HVCardBean mHVCardBean) {
        int mStartTime=mHVCardBean.getStartTime();
        int mEndTime=mHVCardBean.getEndTime();
        return isExpired(mEndTime,mStartTime);
    }
    /**
     * 判断是否过期 并且未生效
     *
     * @return
     */
    private boolean isExpired(int endTime,int mStartTime) {
        long nowTime = System.currentTimeMillis()/1000;//当前时间
        return nowTime > endTime||mStartTime>nowTime;//过期：当前时间大于结束时间  未开始 ：开始时间大于当前时间

    }

    public ArrayList<HVCardBean> orderStatue(){
        if(null!=mAvailableCouponList){//使用服务器指定的可用优惠券
            doServiceCardCanUse();
        }else{
            doLocalCardCanUse();
        }
        getNewList();

        return mNewCarBeans;
    }

    /**
     * 服务器返回的 该订单可用的优惠券
     */

    private void doServiceCardCanUse() {
        for(Integer mAvailableCouponId:mAvailableCouponList){
            Iterator<HVCardBean> iter = mHVCardBeans.iterator();
            while(iter.hasNext()){
                HVCardBean mTempCardBean = iter.next();
                if(mAvailableCouponId!=null&&mTempCardBean.getCouponUserId().equals(mAvailableCouponId)){//卡卷Id对应
                    mTempCardBean.setIsUseAble(true);
                    mNewCarBeans.add(mTempCardBean);
                    iter.remove();
                }
            }
        }
    }

    /**
     * app 端 本地判断优惠券规则 是否符合该订单
     */

    private void doLocalCardCanUse() {
        boolean isGym = isGym(mMyOrderInfoBean.getOrderType().value);//是否是场馆订单
        boolean isAllOrderCanUse;//是否对该类订单都可用
        for (int i=0;i<mHVCardBeans.size();i++) {//遍历我的卡券
            HVCardBean mHVCardBean=mHVCardBeans.get(i);
            boolean isCompileGymId=doIsCompileGymId(mHVCardBean);
            if(!isCompileGymId){//包含了场馆Id
                break;
            }
            int range = mHVCardBean.getRange().value;
            isRemove=false;
            switch (range) {
                case ALL_PRODUCT_AND_GYM://该卡卷对所有的场馆的场地订单 产品订单都可用
                    isAllOrderCanUse = true;
                    doIsCanUse(isGym, mHVCardBean, isAllOrderCanUse);

                    break;
                case ALL_GYM://该卡卷对所有的场馆都可以用 对部分产品可用
                    isAllOrderCanUse = isGym;//如果是产地订单 对所有的订单都有效 如果是产品订单只有部分的才有效
                    doIsCanUse(isGym, mHVCardBean, isAllOrderCanUse);
                    break;

                case ALL_PRODUCT://该卡卷对所有的产品可用对部分场馆订单可用
                    isAllOrderCanUse = !isGym;//如果是产地订单 只有部分的订单都有效 如果是产品订单全部都有效
                    doIsCanUse(isGym, mHVCardBean, isAllOrderCanUse);
                    break;
                case PART_GYM_PART_PRODUCT://指定场馆的产品售卖有效，指定场馆的场地预定有效
                    isAllOrderCanUse = false;
                    doIsCanUse(isGym, mHVCardBean, isAllOrderCanUse);
                    break;
            }
            if(isRemove){
                i=i-1;
            }
        }
    }

    /**
     * 要符合场馆Id
     * @param mHVCardBean 优惠券场馆ID
     */

    private boolean doIsCompileGymId(HVCardBean mHVCardBean) {
        boolean mIsCompileGymId;
        if(StringUtils.isNull(mHVCardBean.categoryIdList)){
            mIsCompileGymId=true;
        }else {
            mIsCompileGymId=mHVCardBean.categoryIdList.contains(mVenueId);
        }
        return mIsCompileGymId;
    }

    private void getNewList() {
        mNewCarBeans.addAll(mCanUseCarbeans);
        mNewCarBeans.addAll(mHVCardBeans);
//        mNewCarBeans.addAll(mNoUseCarbeans);
    }

    /**
     * @param isGym 是否是场馆订单 true 场馆订单 false 产品订单
     * @param mHVCardBean 卡卷bean
     * @param isAllOrderCanUse 是否所有订单都能用
     */

    private void doIsCanUse(boolean isGym, HVCardBean mHVCardBean, boolean isAllOrderCanUse) {
        int couponType= mHVCardBean.getCouponType().value;//卡卷类型
        boolean isFullCut=isFullCut(couponType);//是否是满减
        if(isGym){//场馆订单  判断满减或者抵扣
            doGymIsCanUse(isFullCut,mHVCardBean,isAllOrderCanUse);
        }else{//产品订单
            doProductIsCanUse(mHVCardBean,isAllOrderCanUse);
        }
    }

    /**
     * 该卡卷是否对产品订单 可用
     * @param mHVCardBean 该卡卷的bean
     * @param isAllOrderCanUse 是否对所有的订单都可用
     */

    private void doProductIsCanUse(HVCardBean mHVCardBean, boolean isAllOrderCanUse) {
        double mCondition=mHVCardBean.getCondition();//生效标准
//        if(isFullCut){//满减
         double mAllProductPrice=getAllPrice(false);//所有产品总价
          if(mAllProductPrice>=mCondition){
              if (isAllOrderCanUse) {//
                  mHVCardBean.setIsUseAble(true);
                  mCanUseCarbeans.add(mHVCardBean);
                  mHVCardBeans.remove(mHVCardBean);
                  isRemove=true;
              } else {//productId在优惠卷指定的productId范围内
                  ArrayList<HVCardProductsBean> couponProducts=mHVCardBean.getCouponProducts();
                  for(HVCardProductsBean mHVCardProductsBean:couponProducts){
                      if(productId.equals(mHVCardProductsBean.getProductId())){//符合该产品的productId
                       mHVCardBean.setIsUseAble(true);
                       mCanUseCarbeans.add(mHVCardBean);
                        mHVCardBeans.remove(mHVCardBean);
                          isRemove=true;
                      }
                  }
              }
          }
        /*}else{//抵扣 单个产品的价格大于
           double singlePrice= mMyOrderInfoBean.getOrderProduct().getPrice();//单个产品的单价
            if(singlePrice>mCondition){
                mCanUseCarbeans.add(mHVCardBean);
            }
        }*/

    }

    /**
     * 是否是满减
     * @param couponType 优惠类型
     * @return true 满减  false 抵扣
     */

    private boolean isFullCut(int couponType) {
        return couponType==FULL_CUT;
    }


    /**
     * 该优惠卷对场馆订单是否可用
     * @param isFullCut true满减 false 抵扣
     * @param mHVCardBean 该卡卷的bean
     * @param isAllOrderCanUse 是否所有订单都能生效
     */
    private void doGymIsCanUse(boolean isFullCut, HVCardBean mHVCardBean, boolean isAllOrderCanUse) {
        double mCondition = mHVCardBean.getCondition();//生效金额
        if (isFullCut) {//满减
            double mAllPrice = getAllPrice(true);
            if (mAllPrice >= mCondition) {//总金额大于等于生效金额就加入可用的卡卷列表
                if (isAllOrderCanUse) {//如果在可用的范围直接满足
                    mHVCardBean.setIsUseAble(true);
                    mCanUseCarbeans.add(mHVCardBean);
                    mHVCardBeans.remove(mHVCardBean);
                    isRemove=true;
                } else {//只适用部分订单的卡卷需要判断 有一个场馆在时间 卡卷适用的范围内
                    doPartGym(isFullCut,mHVCardBean);
                }
            }
        } else {//抵扣
            List<HVVenueOrderFieldBean> mHVVenueOrderFieldBeans=mMyOrderInfoBean.getOrderField();
            List<HVVenueOrderFieldBean> mLargeConditionList =getIsLargeCondition(mHVVenueOrderFieldBeans,mCondition,mHVCardBean,isAllOrderCanUse);//大于抵扣生效的金额的场地列表
            if(!StringUtils.isNull(mLargeConditionList)){
                mHVCardBean.setIsUseAble(true);
                mCanUseCarbeans.add(mHVCardBean);
                mHVCardBeans.remove(mHVCardBean);
                isRemove=true;
            }
        }
    }

    /**
     * 这卡卷只是用部分的场馆订单  部分场馆满减  根据场馆Id匹配，并且
     * @param isFullCut 是否是满减
     * @param mHVCardBean 卡卷bean
     */

    private void doPartGym(boolean isFullCut, HVCardBean mHVCardBean) {
        ArrayList<HVCardVenuesBean> mHVCardVenuesBeans=mHVCardBean.getCouponVenues();//优惠券关联场馆
        ArrayList<HVVenueOrderFieldBean> mHVVenueOrderFieldBeans= mMyOrderInfoBean.getOrderField();
        boolean isCanAdd=false;//是否符合抵扣要求
        for(HVCardVenuesBean mHVCardVenuesBean:mHVCardVenuesBeans){//我的卡卷
            String tempGymId=mHVCardVenuesBean.getVenueId();
            if(!StringUtils.isNull(tempGymId)&&gymId.equals(tempGymId)){//当前的场馆id在关联的
                ArrayList<HVCardWorkTimeBean> workTimes=mHVCardVenuesBean.getWorkTimes();
                for(HVVenueOrderFieldBean mHVVenueOrderFieldBean:mHVVenueOrderFieldBeans){//场地的子订单 的时间段
                    int startTime=mHVVenueOrderFieldBean.getStartTime();
                    int endTime=mHVVenueOrderFieldBean.getEndTime();
                    for(HVCardWorkTimeBean mHVCardWorkTimeBean:workTimes){//该场馆支持使用优惠卷的时间段
                        int tempStartHour=mHVCardWorkTimeBean.getStartTimeHour();
                        int tempStartMin=mHVCardWorkTimeBean.getStartTimeMinute();
                        int tempEndHour=mHVCardWorkTimeBean.getEndTimeHour();
                        int tempEndMin=mHVCardWorkTimeBean.getEndTimeMinute();
                        boolean isContain=isContain(startTime,endTime,tempStartHour,tempStartMin,tempEndHour,tempEndMin);
                        if(isContain){//包含
                            mHVCardBean.setIsUseAble(true);
                            isCanAdd=true;
                        }
                    }
                }

            }else if (StringUtils.isNull(tempGymId)){//场馆id为null表示对所有的场馆都适合
                ArrayList<HVCardWorkTimeBean> workTimes=mHVCardVenuesBean.getWorkTimes();
                for(HVVenueOrderFieldBean mHVVenueOrderFieldBean:mHVVenueOrderFieldBeans){//场地的子订单 的时间段
                    int startTime=mHVVenueOrderFieldBean.getStartTime();
                    int endTime=mHVVenueOrderFieldBean.getEndTime();
                    for(HVCardWorkTimeBean mHVCardWorkTimeBean:workTimes){//该场馆支持使用优惠卷的时间段
                        int tempStartHour=mHVCardWorkTimeBean.getStartTimeHour();
                        int tempStartMin=mHVCardWorkTimeBean.getStartTimeMinute();
                        int tempEndHour=mHVCardWorkTimeBean.getEndTimeHour();
                        int tempEndMin=mHVCardWorkTimeBean.getEndTimeMinute();
                        boolean isContain=isContain(startTime,endTime,tempStartHour,tempStartMin,tempEndHour,tempEndMin);
                        if(isContain){//包含
//                            mCanUseCarbeans.add(mHVCardBean);
                            mHVCardBean.setIsUseAble(true);
                            isCanAdd=true;
                        }
                    }
                }
            }
        }
        if(isCanAdd){
            mCanUseCarbeans.add(mHVCardBean);
            mHVCardBeans.remove(mHVCardBean);
            isRemove=true;
        }
    }

    /**
     *
     * @param startTime 场馆的子订单的开始时间戳
     * @param endTime   场馆的子订单的结束时间戳
     * @param tempStartHour 卡卷的开始时间小时
     * @param tempStartMin  卡卷的开始时间分
     * @param tempEndHour 卡卷的结束时间小时
     * @param tempEndMin  卡卷的结束时间分
     * @return 子订单的时间段是否在 卡卷的时间段范围内
     */

    private boolean isContain(int startTime, int endTime, int tempStartHour, int tempStartMin, int tempEndHour, int tempEndMin) {
        boolean isContain=false;
        int year= DateUtil.intToGetYear(startTime);
        int month= DateUtil.intToGetMonth(startTime);
        int day= DateUtil.intToGetDay(startTime);
        //获取卡卷的时间段的时间戳
        Date mDateStart=new Date(year,month,day,tempStartHour,tempStartMin);
        Date mDateEnd=new Date(year,month,day,tempEndHour,tempEndMin);
        long mTempStartTime=mDateStart.getTime()/1000;
        long mTempEndTime=mDateEnd.getTime()/1000;
       /* isContain= mTempStartTime<=startTime
                &&startTime<mTempEndTime
                &&mTempStartTime<endTime
                &&endTime<=mTempEndTime; */
        isContain= mTempStartTime<=startTime
                &&endTime<=mTempEndTime;
        return isContain;
    }

    /**
     * 获取大于抵扣生效的子订单列表
     * @param mHVVenueOrderFieldBeans 场地子订单列表
     * @param mCondition 生效金额
     * @param mHVCardBean
     *@param isAllOrderCanUse 卡卷是否满足所有场地的订单  @return 满足的子订单list
     */

    private List<HVVenueOrderFieldBean> getIsLargeCondition(List<HVVenueOrderFieldBean> mHVVenueOrderFieldBeans, double mCondition, HVCardBean mHVCardBean, boolean isAllOrderCanUse) {
        List<HVVenueOrderFieldBean> mLargeConditionList=new ArrayList<>();
        if (isAllOrderCanUse) {//符合所有的场馆
            for (HVVenueOrderFieldBean mHVVenueOrderFieldBean : mHVVenueOrderFieldBeans) {//大于生效的金额就添加
                double mPrice = mHVVenueOrderFieldBean.getPrice();
                if (mPrice >= mCondition) {
                    mLargeConditionList.add(mHVVenueOrderFieldBean);
                }
            }
        }else {//抵扣部分场馆
            ArrayList<HVCardVenuesBean> mHVCardVenuesBeans=mHVCardBean.getCouponVenues();//优惠券关联场馆
            for(HVCardVenuesBean mHVCardVenuesBean:mHVCardVenuesBeans){
                String tempGymId=mHVCardVenuesBean.getVenueId();
                if(!StringUtils.isNull(tempGymId)&&gymId.equals(tempGymId)){//符合的场馆
                    ArrayList<HVCardWorkTimeBean> workTimes=mHVCardVenuesBean.getWorkTimes();
                    //TODO 优惠卷的价格 取符合的最大
                    for (HVVenueOrderFieldBean mHVVenueOrderFieldBean:mHVVenueOrderFieldBeans){
                        int startTime=mHVVenueOrderFieldBean.getStartTime();
                        int endTime=mHVVenueOrderFieldBean.getEndTime();
                        double mPrice = mHVVenueOrderFieldBean.getPrice();
                        for(HVCardWorkTimeBean mHVCardWorkTimeBean:workTimes){//该场馆支持使用优惠卷的时间段
                            int tempStartHour=mHVCardWorkTimeBean.getStartTimeHour();
                            int tempStartMin=mHVCardWorkTimeBean.getStartTimeMinute();
                            int tempEndHour=mHVCardWorkTimeBean.getEndTimeHour();
                            int tempEndMin=mHVCardWorkTimeBean.getEndTimeMinute();
                            boolean isContain=isContain(startTime,endTime,tempStartHour,tempStartMin,tempEndHour,tempEndMin);
                            if(isContain&&mPrice >= mCondition){//包含
                                mLargeConditionList.add(mHVVenueOrderFieldBean);
                                //判断当前的可用价格和当前的
                            }
                        }
                    }

                }else if(StringUtils.isNull(tempGymId)){//如果场馆id为null就表示对所有的都适合
                    ArrayList<HVCardWorkTimeBean> workTimes=mHVCardVenuesBean.getWorkTimes();
                    //TODO 优惠卷的价格 取符合的最大
                    for (HVVenueOrderFieldBean mHVVenueOrderFieldBean:mHVVenueOrderFieldBeans){
                        int startTime=mHVVenueOrderFieldBean.getStartTime();
                        int endTime=mHVVenueOrderFieldBean.getEndTime();
                        double mPrice = mHVVenueOrderFieldBean.getPrice();
                        for(HVCardWorkTimeBean mHVCardWorkTimeBean:workTimes){//该场馆支持使用优惠卷的时间段
                            int tempStartHour=mHVCardWorkTimeBean.getStartTimeHour();
                            int tempStartMin=mHVCardWorkTimeBean.getStartTimeMinute();
                            int tempEndHour=mHVCardWorkTimeBean.getEndTimeHour();
                            int tempEndMin=mHVCardWorkTimeBean.getEndTimeMinute();
                            boolean isContain=isContain(startTime,endTime,tempStartHour,tempStartMin,tempEndHour,tempEndMin);
                            if(isContain&&mPrice >= mCondition){//包含
                                mLargeConditionList.add(mHVVenueOrderFieldBean);
                            }
                        }
                    }
                }
            }

        }
        return mLargeConditionList;
    }

    /**
     * 获取订单的总价格
     * @param isGym 是否是场馆订单
     * @return
     */

    private double getAllPrice( boolean isGym) {
        double allOrderPrice=0;
        if(isGym){//场馆订单
            List<HVVenueOrderFieldBean> mHVVenueOrderFieldBeans=mMyOrderInfoBean.getOrderField();//场馆子订单列表
            for(HVVenueOrderFieldBean mHVVenueOrderFieldBean:mHVVenueOrderFieldBeans){
                allOrderPrice+=mHVVenueOrderFieldBean.getPrice();
            }
        }else{//产品订单
            HVProductOrderFieldBean mHVProductOrderFieldBean=mMyOrderInfoBean.getOrderProduct();//产品子订单
            allOrderPrice=mHVProductOrderFieldBean.getPrice()*mHVProductOrderFieldBean.getNumber();
        }
        return allOrderPrice;
    }

    /**
     * 订单类型
     * @param type    Venue(1),	//场馆
                   Product(2);	// 产品
     * @return
     */

    public boolean isGym(int type){
        boolean isGym=type==GYM;
        return isGym;
    }

    /**
     * 当前的卡卷
     * @param mCurHVCardBean 卡卷Bean
     * @return
     */

    public ArrayList<HVCardBean> getIsSelctedList(HVCardBean mCurHVCardBean){
        String mCurCardId=mCurHVCardBean.getCouponId();
        for(HVCardBean mHvCardBean:mNewCarBeans){
            String mTempCardId=mHvCardBean.getCouponId();//卡卷Id
                if(mCurCardId.equals(mTempCardId)){//当前bean为已选中
                    mHvCardBean.setIsSelcted(true);
                }
        }
        return mNewCarBeans;
    }

    /**
     *
     * @param mSelectedCardId 选中的卡卷Id
     * @return ArrayList<HVCardBean> 选中的列表
     */

    public ArrayList<HVCardBean> getIsSelctedList(Integer mSelectedCardId){
        boolean isHaveSelect=false;//是否含有该优惠劵
        for(HVCardBean mHvCardBean:mNewCarBeans){
            Integer mTempCardId=mHvCardBean.getCouponUserId();//卡卷Id
                if(mSelectedCardId.equals(mTempCardId)){//当前bean为已选中
                    mHvCardBean.setIsSelcted(true);
                    isHaveSelect=true;
                }
        }
        //同一订单的优惠劵需要显示出来
        if (!isHaveSelect) {//没有找到就在已使用的列表中遍历
            for (HVCardBean mTempHvCardBean : mNoUseCarbeans) {
                Integer mTempCardId = mTempHvCardBean.getCouponUserId();//卡卷Id
                if (mSelectedCardId.equals(mTempCardId) && !doCheckIsOver(mTempHvCardBean)) {//当前bean为已选中 并且不过期的情况下
                    mTempHvCardBean.setIsSelcted(true);
                    mTempHvCardBean.setIsUseAble(true);
                    mNewCarBeans.add(0, mTempHvCardBean);
                }
            }
        }
        return mNewCarBeans;
    }

    /**
     * 在卡卷符合规则后 获取折扣后的价格
     * @param mCardBean 卡卷bean
     * @param mOrderInfo 订单详情
     */

    public double getDiscoundPrice(HVCardBean mCardBean, HVMyOrderInfoBean mOrderInfo) {
        int couponType = mCardBean.getCouponType().value;//卡卷类型
        double mAllPrice = mOrderInfo.getActualPrice();
        boolean isFullCut = isFullCut(couponType);//是否是满减
        double mDiscoundPrice;
        double mReduction = mCardBean.getMoney();//减额
        ArrayList<HVVenueOrderFieldBean> orderField = mOrderInfo.getOrderField();//场地子订单
        if (isFullCut) {//满减
            mDiscoundPrice = doPriceNotEnough(mAllPrice, mReduction);
        } else {//抵扣
            boolean isGym = isGym(mMyOrderInfoBean.getOrderType().value);//是否是场馆订单
            if (isGym) {//场馆订单的抵扣
                mDiscoundPrice = doGymDeductible(orderField, mReduction);
            } else {//产品订单的抵扣 逻辑跟满减一样
                mDiscoundPrice = doPriceNotEnough(mAllPrice, mReduction);
            }
        }
        return mDiscoundPrice;
    }
    /**
     * 计算场地订单的抵扣
     * @param orderFields 子订单的裂变
     * @param mReduction 减额
     */

    private double doGymDeductible(ArrayList<HVVenueOrderFieldBean> orderFields, double mReduction) {
        double mDiscoundPrice=0;
        if(orderFields.size()==1){//只有一个子订单
            mDiscoundPrice=doPriceNotEnough(orderFields.get(0).getPrice(),mReduction);
        }else{//多个子订单
            for (HVVenueOrderFieldBean mFiedlBean:orderFields){
                double mTempDiscoundPrice;
                double mSinglePrice=mFiedlBean.getPrice();
                mTempDiscoundPrice=doDiscoutMoney(mSinglePrice,mReduction);
                if(mTempDiscoundPrice>mDiscoundPrice){//取最大的减额
                    mDiscoundPrice=mTempDiscoundPrice;
                }
            }
        }
        return mDiscoundPrice;
    }

    /**
     * 当价格小于优惠券的减额  保留0.01元
     * @param mPrice 价格
     * @param mReduction 减额
     */

    private double doPriceNotEnough(double mPrice, double mReduction) {
        double mDiscoundPrice;
        if(mPrice<=mReduction){//保留一分钱
            mDiscoundPrice=Arith.sub(mPrice,0.01);
        }else
            mDiscoundPrice=mReduction;

        return mDiscoundPrice;
    }

    /**
     * 抵扣金额
     * @param mPrice 价格
     * @param mReduction 减额
     * @return 抵扣间隔
     */

    private double doDiscoutMoney(double mPrice ,double mReduction){
        double mDiscoundPrice;
        if(mPrice<=mReduction){
            mDiscoundPrice=mPrice;
        }else
            mDiscoundPrice=mReduction;

        return mDiscoundPrice;
    }
}
